Enabling multi-tenant access to respective isolated data sets organized using different application schemas

ABSTRACT

Multi-tenant access to respective isolated data sets organized using different application schemas is disclosed. Multiple tenants store respective data sets in separate datastores. The datastores are organized using different application schemas, each derived from a same base schema. However, the tenants share access to a same application. The application receives a first request from a first tenant and a second request from a second tenant. The application serves the first request by accessing a first data set organized using a first application schema. The application serves the second request by accessing a second data set using a second application schema.

INCORPORATION BY REFERENCE; DISCLAIMER

Each of the following applications are hereby incorporated by reference: application Ser. No. 14/973,256 filed on Dec. 17, 2015; application Ser. No. 14/973,325 filed Dec. 17, 2015; application Ser. No. 13/631,815 filed Sep. 28, 2012; Application No. 61/707,726 filed Sep. 28, 2012; application No. 61/707,726 filed Sep. 28, 2012. The Applicant hereby rescinds any disclaimer of claim scope in the parent application(s) or the prosecution history thereof and advises the USPTO that the claims in this application may be broader than any claim in the parent application(s).

TECHNICAL FIELD

The present disclosure relates to multi-tenant, cloud-based hardware and/or software services. In particular, the present disclosure relates to enabling multi-tenant access to respective isolated data sets organized using different application schemas.

BACKGROUND

In a multi-tenant, cloud-based environment, multiple tenants use one or more applications executing on shared computing resources. The shared computing resources may be located in data centers off the tenant's own premises (referred to herein as an “off-premise environment”).

In some cloud-based environments, a separate instance of a server is created for each tenant, either physically or via virtualization. Each instance of a server implements separate application code and application schema for each tenant.

In other cloud-based environments, a shared instance of a server is created for multiple tenants. The shared instance of the server implements the same application code for multiple tenants. The shared instance of the server also implements a common application schema for the tenants. Data sets for the multiple tenants are organized using the common application schema and indexed by tenant identifier (ID).

The approaches described in this section are approaches that could be pursued, but not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.

BRIEF DESCRIPTION OF THE DRAWINGS

The embodiments are illustrated by way of example and not by way of limitation in the figures of the accompanying drawings. It should be noted that references to “an” or “one” embodiment in this disclosure are not necessarily to the same embodiment, and they mean at least one. In the drawings:

FIG. 1A illustrates a multi-datastore architecture, in accordance with one or more embodiments;

FIG. 1B illustrates an example of multiple pluggable databases executing under one instance of a container database, in accordance with one or more embodiments;

FIG. 2 illustrates an example set of operations for enabling multi-tenant access to respective isolated data sets organized using different application schemas, in accordance with one or more embodiments;

FIGS. 3A and 3B illustrate example sets of operations for updating a base schema and customizing an application schema, in accordance with one or more embodiments;

FIG. 4A illustrates an example of accessing isolated data sets using a same application in accordance with one or more embodiments;

FIG. 4B illustrates an example of different application schemas in accordance with one or more embodiments; and

FIG. 5 shows a block diagram that illustrates a computer system in accordance with one or more embodiments.

DETAILED DESCRIPTION

In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding. One or more embodiments may be practiced without these specific details. Features described in one embodiment may be combined with features described in a different embodiment. In some examples, well-known structures and devices are described with reference to a block diagram form in order to avoid unnecessarily obscuring the present invention.

-   -   1. GENERAL OVERVIEW     -   2. MULTI-DATASTORE ARCHITECTURE         -   a. DATABASE INSTANCE         -   b. PLUGGABLE DATABASE         -   c. DATABASE STRUCTURE WITHIN DATABASE INSTANCE     -   3. ENABLING MULTI-TENANT ACCESS TO RESPECTIVE ISOLATED DATA SETS         ORGANIZED USING DIFFERENT APPLICATION SCHEMAS     -   4. UPDATING A BASE SCHEMA AND CUSTOMIZING AN APPLICATION SCHEMA     -   5. EXAMPLE EMBODIMENTS     -   6. CLOUD ENVIRONMENTS     -   7. MISCELLANEOUS; EXTENSIONS     -   8. HARDWARE OVERVIEW

1. General Overview

One or more embodiments include a same application code providing multiple tenants access to different datastores. At least two of the datastores are organized using different respective application schemas. The different application schemas are derived from a same base schema that is associated with the application code. The base schema indicates the names of data fields, the number of data fields, the number of tables, and other aspects of a default datastore that is used by the particular application. The application schema is a modified and/or customized version of the base schema. The application schema may modify the names of data fields, the number of data fields, the number of tables, and other aspects of the base schema. A modification of an application schema associated with a datastore corresponding to a particular tenant does not affect the application schemas associated with datastores corresponding to other tenants. Each application schema may have, for example, a different number of data fields. Meanwhile, a modification of the base schema is applied across various application schemas associated with datastores corresponding to various tenants.

2. Multi-Datastore Architecture

FIG. 1A illustrates a multi-datastore architecture in accordance with one or more embodiments. The multi-datastore architecture (including modifications thereof) may be used in serving data from multiple datastores. The multi-datastore architecture is illustrated in FIG. 1A as a system of components, referred to as system 100.

As illustrated in FIG. 1A, system 100 includes tenants 112-114, application 116, base schema 118, application schemas 122-124, and data sets 132-134. In one or more embodiments, system 100 may include more or fewer components than the components illustrated in FIG. 1A. The components illustrated in FIG. 1A may be local to or remote from each other. The components illustrated in FIG. 1A may be implemented in software and/or hardware and may be distributed over one or more applications and/or machines. Operations described with respect to one component may instead be performed by another component.

In one or more embodiments, a tenant (such as tenant 112 and/or tenant 114) is a corporation, organization, enterprise or other entity that accesses a shared computing resource, such as application 116. In an embodiment, tenant 112 and tenant 114 are independent from each other. A business or operation of tenant 112 is separate from a business or operation of tenant 114. As described below, data and operations associated with different tenants may be isolated from one another.

In an embodiment, system 100 is implemented using devices that are remote from the premises of tenant 112 and tenant 114. Devices executing application 116, a datastore having application schema 112, and/or a datastore having application schema 124 are remote from tenant 112 and tenant 114. The devices are accessed via a public network, such as the Internet, using a communications protocol, such as Hypertext Transfer Protocol (HTTP). As an example, system 100 may include one or more data centers that are located remote to corporate offices.

In an embodiment, system 100 is used to provide a cloud-based environment to tenant 112 and tenant 114. The cloud environment includes a centralized pool of resources that are shared amongst the multiple tenants 112-114. Examples of resources include a processor, a server, a data storage, a virtual machine, and a platform. Client devices of tenants 112-114 may independently request computing services, such as server time and network storage, as needed. The resources assigned to each particular client device may be scaled up or down based on the computing services requested by the particular client device. The resources assigned to each particular client device may also be scaled up or down based on the aggregated demand for computing services requested by all client devices.

In an embodiment, data sets stored using system 100 that correspond to different tenants are isolated from each other. As illustrated in FIG. 1A, data set 132 corresponds to tenant 112, and data set 134 corresponds to tenant 114. Tenant isolation may be achieved using, for example, tenant identifiers (IDs), application schemas 122-124, and/or tenant-specific overlay networks. Examples of operations executed within a cloud environment to manage resources and implement tenant isolation are described below in Section 5, titled “Cloud Environments.”

Continuing with FIG. 1A, application 116 includes executable code and/or logic that is configured to execute operations, such as retrieving and/or accessing one or more data sets 132-134. Application 116 is a shared computing resource available to tenants 112-114. Application 116 executes on hardware (such as one or more servers and/or computers) located in an environment (such as a data center) that is remote from the premises of tenant 112 and tenant 114 (referred to herein as an “off-premise environment”).

In one or more embodiments, base schema 118 indicates the names of data fields, the number of data fields, the number of tables, and other aspects of a default datastore that is used by application 116. Base schema 118 indicates the basic features and/or functions of a default datastore that is used by application 116. Base schema 118 is shared amongst tenants 112-114 and is modified and/or customized to form application schemas 122-124.

In one or more embodiments, an application schema (such as application schema 122 and/or application schema 124) indicates the names of data fields, the number of data fields, the number of tables, and other aspects of a particular datastore that is used by application 116. The particular datastore corresponds to a particular tenant (such as tenant 112 and/or tenant 114). The particular datastore may be implemented on hardware that is shared amongst tenants in an off-premise environment. Additionally or alternatively, the particular datastore may be implemented on hardware that is located at the premises of the particular tenant (referred to herein as an “on-premise environment”). Differences between base schemas and application schemas are further detailed below.

In an embodiment, each data field is associated with a name and a data field identifier (ID). A name of a data field, as referred to herein, is a set of words, text, and/or characters, that is displayed at a user interface to reference the data field. As an example, a particular data field may be named, “Date.” A user interface may display a textbox for inputting a value into the particular data field. The user interface may display the name “Date” adjacent to the textbox, to indicate which data field is being modified by user input entered into the textbox. An identifier of a data field, as referred to herein, is a set of words, text, and/or characters, that is used by executable code and/or logic of application 116 to reference the data field. As an example, a particular data field may have the identifier, “1234.” An application may perform certain operations on the particular data field. The application may reference the particular data field by using the identifier, “1234.” Each application schema may have different sets of data fields. A particular application schema may have a data field that overlaps with a data field of another application schema. A particular application schema may have a data field that is unique to the particular application schema and not included in other application schemas derived from a same base schema. Examples of overlapping data fields and unique fields are described in the examples below.

As an example, a data field of application schema 122 and another data field of application schema 124 may have a same data field ID but may be referenced by different names. The data field of application schema 122 and the data field of application schema 124, having the same data field ID, may be an overlapping data field of application schema 122 and application schema 124. The same data field ID would indicate that the same operations may be performed, by an application 116, on the data field of application schema 122 and the data field of application schema 124. However, the data fields may be referred to using different names. The different names may be, for example, “First Name” and “Given Name,” both referring to a name of an individual.

As another example, a data field with a particular data field ID may exist in application schema 122 but not in application schema 124. The data field with the particular data field ID may be a unique data field to application schema 122. The data field may have been added in application schema 122 through customization of application schema 122. But the data field was not added in application schema 124.

In an embodiment, application schemas 122-124 are derived from base schema 118. A first set of modifications are made to base schema 118 to form application schema 122, and a second (different) set of modifications are made to base schema 118 to form application schema 124. The first set of modifications may include, for example, modifying a name of a data field already existing in base schema 118. The second set of modifications may include, for example, adding a data field for storing data that is applicable to tenant 114 but not to tenant 112. Hence, application schema 122 and application schema 124 indicate different names of data fields, different numbers of data fields, different numbers of tables, and/or other differences.

As an example, a base schema may be associated with storing data sets related to vehicles. A first application schema may be associated with pickup trucks. A data field that is applicable to pickup trucks and not already existing in the base schema may be a size of the truck bed. A data field for the size of the truck bed may be added to the base schema to form the first application schema. Meanwhile, a second application schema may be associated with sedans. The size of the truck bed may not be applicable to sedans. Therefore the data field for the size of the truck bed is not included in the second application schema.

In an embodiment, application schemas 122-124 are used to organize data sets (such as data sets 132-134) that are to be accessed by a same application 116 that is associated with base schema 118. As an example, a particular application may be associated with a base schema. The base schema may be associated with storing data sets related to vehicles. A first application schema, derived from the base schema, may be associated with pickup trucks. A second application schema, derived from the base schema, may be associated with sedans. The particular application may be used to access a first data set organized using the first application schema. The particular application may also be used to access a second data set organized using the second application schema.

In an embodiment, application schemas 122-124 correspond to different datastores. A datastore includes one or more data structures for organizing one or more data sets (such as data set 132 and/or data set 134) using an application schema (such as application schema 122 and/or application schema 124). Examples of data structures include a table, an array, a linked list, a tree, and a container (which is a collection of data structures). The organization of a datastore enables the contents of the datastore to be accessed, managed, and/or updated by a computer.

In an embodiment, various implementations of datastores may be used. Examples of datastores include a database instance, a pluggable database, and a data structure within a database instance, each of which is further described below.

A. Database Instance

In an embodiment, application schemas 122-124 correspond to different database instances. A database instance is a physical database and includes a set of memory structures and background processes for organizing a data set.

In an embodiment, memory structures of a datastore include a buffer cache, a redo log, and/or a shared pool. A buffer cache stores copies of data blocks currently or recently read from the data set. On a subsequent access request, the cached data blocks may be retrieved from the buffer cache rather than the data set.

A redo log stores redo entries, which describe current or recent changes made to the data set. In case of failure with the database instance and/or the data set, the redo log may be used to restore the most current version of the data set.

A shared pool stores copies of various current or recent program data. The shared pool stores parsed code (such as commands in Structured Query Language (SQL) or Java) for accessing the data set. On subsequent calls to the same code, the parsed code may be re-executed from the shared pool. Additionally or alternatively, the shared pool stores results returned from a query and/or a function. Results include, for example, a subset of a data set that matches criteria of a particular query.

In an embodiment, background processes of a datastore include a background monitoring process, a listener registration process, and a database writer process. A background monitoring process is configured to monitor the database instance and perform process recovery in case a process fails. Process recovery includes freeing up resources that were being used by the failed process, such as releasing database locks. The background monitoring process executes periodically, for example, every 3 seconds.

A listener registration process is configured to register a database instance with a listener. The listener is a server-side process that listens for incoming client connection requests and manages client traffic to the data set. The listener registration process provides the listener with the name and/or identifier of the database instance, and the addresses of service handlers of the database instance. A service handler is a process that serves as a connection point to a data set. The registration information enables the listener to select an appropriate service handler when a client request arrives and forward the client request to the selected service handler.

A database writer process is configured to write contents of a buffer cache to the data set, which may be stored on disk. The database writer process executes periodically and/or on an on-demand basis (such as, when no clean buffer caches are available).

B. Pluggable Database

In an embodiment, application schemas 122-124 correspond to different pluggable databases that execute under one instance, or copy, of a container database. The container database holds the functionality and metadata that applies to all pluggable databases included therein. Each pluggable database includes a separate schema for the corresponding pluggable database. Examples of pluggable databases are described in U.S. patent application Ser. No. 13/631,815, filed Sep. 28, 2012, now published as U.S. Patent Application Publication No. 2014/0095530, published Apr. 3, 2014, which claims priority to U.S. Provisional Patent Application No. 61/707,726, filed Sep. 28, 2012; and U.S. Provisional Patent Application No. 61/707,726, filed Sep. 28, 2012; which are hereby incorporated by reference.

FIG. 1B illustrates an example of multiple pluggable databases executing under one instance of a container database, in accordance with one or more embodiments. As illustrated in FIG. 1B, system 101 includes tenants 112-114, an application 116, and container database 182. Container database 182 includes root 184, seed 186, pluggable database 188, and pluggable database 190. In one or more embodiments, system 101 may include more or fewer components than the components illustrated in FIG. 1B. The components illustrated in FIG. 1B may be local to or remote from each other. The components illustrated in FIG. 1B may be implemented in software and/or hardware and may be distributed over one or more applications and/or machines. Operations described with respect to one component may instead be performed by another component.

In an embodiment, system 101 operates in an off-premise environment (such as off-premise environment 104 in FIG. 1A). Application 116 is a shared computing resource of tenants 112-114. Application 116 accesses container database 182 to access data sets, of tenant 112 and/or tenant 114, stored at pluggable database 188 and/or pluggable database 190.

In an embodiment, container database 182 includes metadata that is used for organizing data sets across pluggable database 188 and pluggable database 190. The metadata is stored at root 184 and/or seed 186. Container database 182 further includes none, one, or more pluggable databases.

In an embodiment, container database 182 is implemented as a database instance. Container database 182 includes a set of memory structures (such as a buffer cache, redo log, and shared pool) and background processes (such as a background monitoring process, a listener registration process, and a database writer process).

In an embodiment, root 184 stores one or more code packages (such as SQL packages, or Procedural Language Extensions to SQL (PL/SQL) packages) common to accessing pluggable database 188 and pluggable database 190. A code package serves as an interface between application 116 and pluggable databases 188-190. The code package declares the types, variables, constants, exceptions, cursors, and subprograms available for use by application 116. Root 184 also stores common users, which are users that may access container database 182 and all pluggable databases 188-190 of container database 182.

In an embodiment, seed 186 is a template that container database 182 uses to generate new pluggable databases 188-190. Tenants 112-114 may not modify seed 186. In an embodiment, seed 186 includes base schema 118 as the template. As described above, base schema 118 indicates the names of data fields, the number of data fields, the number of tables, and other aspects of a default datastore that is used by application 116. Alternatively (not shown), seed 186 includes a template that has less data fields than base schema 118. Base schema 118 is derived from seed 186 and used in a pluggable database (such as pluggable database 188 and/or pluggable database 190).

In an embodiment, a pluggable database (such as pluggable database 188 and/or pluggable database 190) includes specific features for organizing a data set of a tenant (such as tenant 112 and/or tenant 114). Pluggable database 188 stores a data set of tenant 112, and pluggable database 190 stores a data set of tenant 114. Each pluggable database is derived from seed 186 (or another pluggable database) and modifiable by a tenant. In an embodiment, application schema 122 is used in pluggable database 188, and application schema 124 is used in pluggable database 190. Each of applicable schema 122 and application schema 124 is derived from base schema 118.

In an embodiment, each pluggable database relies on the set of memory structures (such as a buffer cache, redo log, and shared pool) of container database 182. Each pluggable database relies on the background processes (such as a background monitoring process, a listener registration process, and a database writer process) of container database 182. Each pluggable database does not have a separate set of memory structures and/or background processes performing the functions of container database 182.

C. Data Structure within Database Instance

In an embodiment, application schemas 122-124 correspond to separate data structures within a same database instance. As described above, a database instance is a physical database, requiring certain memory structures and background processes. Meanwhile, the separate data structures may not necessarily have individual respective memory structures and background processes. As an example, the separate data structures may rely on and share the background monitoring process of the database instance. As another example, the separate data structures may rely on and share the buffer cache of the database instance. The database instance is a datastore of the data structures contained therein. Each data structure is a datastore of a collection of data corresponding to a tenant.

In an embodiment, the separate data structures within a same database instance may be associated with different characteristics. As an example, separate data structures within a same database instance may be separate tables within a same database instance. As an example, the separate data structures may be of different types (such as a relational database, or an object-oriented database). As an example, the separate data structures may be accessed via different processes. A first set of processes, responding to requests received at a first port of a server, may be used to access a first data structure. A second set of processes, responding to requests received at a second port of a server, may be used to access a second data structure. As an example, the separate data structures may be set with different configurations. One example configuration is a caching policy, including for example the size of the cache, and triggers for caching. Another example configuration is an isolation level, which defines how and when changes to a data set made by one operation become visible to other operations. Another example configuration is a logging level, specifying the events (such as warnings, errors, and critical errors) that are to be logged.

3. Enabling Multi-Tenant Access to Respective Isolated Data Sets Organized Using Different Application Schemas

FIG. 2 illustrates an example set of operations for enabling multi-tenant access to respective isolated data sets organized using different application schemas, in accordance with one or more embodiments. One or more operations illustrated in FIG. 2 may be modified, rearranged, or omitted all together. Accordingly, the particular sequence of operations illustrated in FIG. 2 should not be construed as limiting the scope of one or more embodiments.

One or more embodiments include receiving a request, from a tenant of a set of tenants, for accessing a data set corresponding to the tenant (Operation 202). The data set is one of a group of data sets corresponding respectively to multiple tenants. Each data set is organized using a different application schema derived from a base schema. A set of user interface elements is rendered for each tenant by a same application. The request from the tenant is received through the corresponding set of user interface elements rendered for the tenant. As an example, a request may be received via the Internet using HTTP.

In an embodiment, requests received from different tenants (during the same time period or during different time periods) are substantially similar. As an example, each request may seek to access the first and last names of the employees of the corresponding tenant. Each request may include a same command and a set of parameters referring to the “first name” and “last name” of the corresponding datastore.

As another example, each request may seek to access data fields, having a same data field ID, of different data sets. However, while the data fields may have a same data field ID, the data fields may be referenced using different names in different data sets. The requests would be substantially similar to each other.

As another example, each request, received from different tenants, may be received through a same set of user interactions with a same set of user interface elements (such as clicking a same “Submit” button on a same page, each page being rendered at different browsers for different tenants). The same set of user interface elements may have different configurations, based on customizations made by each tenant. For example, a particular user interface element rendered for a first tenant may be labeled with the text “Department,” while the particular user interface element rendered for a second tenant may be labeled with the text “Office.” “Department” and “Office” may be different names referring to a same data field used by the first tenant and the second tenant.

As noted above, each data set is organized using a different application schema derived from a base schema. After a tenant subscribes to an application, the base schema associated with the application is copied as an application schema for a datastore of the tenant. The tenant may optionally modify and/or customize the application schema. For example, the tenant may change the name of data fields and/or add new data fields. Each tenant may make different modifications, thereby resulting in different application schemas for different tenants.

One or more embodiments include determining a tenant associated with a request (Operation 204). Each request includes a user identifier (ID) of a user account that is being used to initiate the request. The user ID may correspond to a human user's ID or a machine ID (e.g., a Media Access Control address or an Internet Protocol address). The user ID may correspond to a session ID associated with a user's current session. The user ID is mapped to a corresponding tenant ID. The tenant is determined based on the tenant ID.

As an example, a request may be received from a user account having a user ID, “peter_brown.” A look-up table may map the user ID, “peter_brown,” to a tenant ID, “Company_xyz.” The tenant associated with the request would be determined to be “Company_xyz.”

One or more embodiments include determining an application schema associated with the request based on the tenant associated with the request (Operation 206). Determining the application schema based on the tenant may include executing a query based on a tenant identifier to obtain an application schema corresponding to the tenant. Metadata, a database, a table, or other memory may be used to store a mapping between tenant identifiers and corresponding application schemas. Additionally or alternatively, determining the application schema based on the tenant may include identifying a data set associated with the tenant. After identifying the data set associated with the tenant, the application schema associated with the data set is determined.

In an embodiment, metadata describing application schemas corresponding to each tenant is maintained as the application schemas are modified and/or customized by the tenants. The metadata describes the names of data fields, the number of data fields, the number of tables, and other aspects of the datastore of each tenant. The metadata is stored as part of the shared application accessed by the multiple tenants and/or on another shared computing resource used by the tenants.

In an embodiment, the metadata includes a mapping of tenant IDs to the corresponding customizations made by each tenant. A look-up of the metadata using a tenant ID associated with a particular request indicates the application schema associated with the particular request.

One or more embodiments include selecting a set of operations for accessing the data set based on the application schema (Operation 208). Selecting the set of operations may include, for example, selecting commands and/or data fields for execution of the commands. In an embodiment, sets of operations corresponding to different applications schemas include different sets of commands and/or different sets of data fields (referred to as parameters) upon which the commands are to be executed. As an example, two sets of operations corresponding to two different application schemas include (a) a same set of commands and (b) different data fields.

As an example, a first application schema associated with a first request may have three data fields, with the following data field IDs and data field names:

Data Field ID #1: “Sale Date”;

Data Field ID #2: “Quantity”; and

Data Field ID #3: “Price Per Unit.”

A second application schema associated with a second request may have four data fields, with the following data field IDs and data field names:

Data Field ID #1: “Date of Sale”;

Data Field ID #2: “Quantity”;

Data Field ID #3: “Price Per Unit”; and

Data Field ID #4: “Profit Per Unit.”

A first request from a first tenant and a second request from a second tenant may both request the sales information from the past quarter from a same application. The first request may seek the sales information of the first tenant. The second request may seek the sales information of the second tenant.

A method for accessing the sales information may execute various operations, including an operation for retrieving/displaying the sales information on a page of a browser. The method may indicate that the number of parameters to be input into the retrieving/displaying operation is the same as the number of sales-related data fields of the corresponding application schema.

For the first request, the retrieving/displaying operation would include three parameters, Data Field ID #1, Data Field ID #2, and Data Field ID #3. The operation would return the “Sales Date,” “Quantity,” and “Price Per Unit” information for the past quarter.

For the second request, the retrieving/displaying operation would include four parameters, Data Field ID #1, Data Field ID #2, Data Field ID #3, and Data Field #4. The operation would return the “Date of Sale,” “Quantity,” “Price Per Unit,” and “Profit Per Unit” information for the past quarter.

In an embodiment, different sets of operations, within a same method, are to be performed for different application schemas. The operations are selected based on a look-up table and/or logic statements. Additionally or alternatively, different methods are defined for different application schemas.

As an example, an application may provide a method for printing sales information. If the number of data fields is five or less, then the sales information is to be printed on one piece of paper. If the number of data fields is between six and ten, then the sales information is to be printed on two pieces of paper.

The method may include an if statement, inquiring whether the number of data fields is five or less. If so, then a first set of operations that lays out the sales information onto one page are to be executed. The method may include another if statement, inquiring whether the number of data fields is between six and ten. If so, then a second set of operations that lays out the sales information onto two pages are to be executed.

As another example, an application may include a table indicating which methods correspond to which application schemas. Different methods may correspond to a same request, as received by the application. A first method, including a first set of operations, is to be called if a first application schema is being used. A second method, including a second set of operations, is to be called if a second application schema is being used.

One or more embodiments include executing the set of operations, associated with the request, to access the data set corresponding to the tenant associated with the request (Operation 210). The data set corresponding to a particular tenant is identified using a tenant ID and/or an application schema. The set of operations are executed with respect to the data set corresponding to the particular tenant.

In an embodiment, data sets are stored in pluggable databases. Each pluggable database is associated with a tenant ID. A request is made by a particular tenant with tenant ID #xyz. Using tenant ID #xyz, the request may cause access to only the pluggable database associated with tenant ID #xyz. Hence, only data sets corresponding to the particular tenant may be accessed by the particular tenant.

In an embodiment, data sets are stored in different data structures within a same database instance. Each data structure is associated with a tenant ID. A request is made by a particular tenant with tenant ID #xyz. Using tenant ID #xyz, the request may cause access to only the data structure associated with tenant ID #xyz. Hence, only data sets corresponding to the particular tenant may be accessed by the particular tenant.

In an embodiment, data sets are accessed using applications schemas. Each application schema is associated with a different tenant ID. A request is made by a particular tenant with tenant ID #xyz. Metadata indicates that tenant ID #xyz is associated with a particular application schema. Using the particular application schema, the request may cause access to only the data set organized using the particular application schema. Hence, only data sets corresponding to the particular tenant may be accessed by the particular tenant.

One or more embodiments include transmitting a response generated by executing the set of operations to the tenant (Operation 212). A response to a request of a particular tenant is transmitted to the particular tenant. Each response is transmitted using a same application. As an example, each response may be presented using a same set of user interface elements. The same set of user interface elements may be rendered by a same application at different browsers for different tenants. The same set of user interface elements may be used to present different data sets for each response. As an example, a response may be transmitted via the Internet using HTTP.

4. Updating a Base Schema and Customizing an Application Schema

FIG. 3A illustrates an example set of operations for updating a base schema, in accordance with one or more embodiments. One or more operations illustrated in FIG. 3A may be modified, rearranged, or omitted all together. Accordingly, the particular sequence of operations illustrated in FIG. 3A should not be construed as limiting the scope of one or more embodiments.

One or more embodiments include receiving an update for a base schema (Operation 302). The update is received from an entity that created and/or manages a particular application associated with the base schema (such as an application vendor). As an example, the update may be received via the Internet using HTTP.

One or more embodiments include applying the update for the base schema to each application schema that is derived from the base schema (Operation 304). Each application schema is modified to incorporate the update.

As an example, a particular base schema may include two data fields, “First Name” and “Last Name.” A first application schema and a second application schema may both be derived from a particular base schema. The first application schema may have added a data field named “Residential Address.” The second application schema may have added a data field named “Office Address.” An update for the particular base schema may be to add another data field named “Age.” The update may be applied to the first application schema and the second application schema. The first application schema would then include the data fields, “First Name,” “Last Name,” “Age,” and “Residential Address.” The second application schema would then include the data fields, “First Name,” “Last Name,” “Age,” and “Office Address.”

FIG. 3B illustrates an example set of operations for customizing an application schema, in accordance with one or more embodiments. One or more operations illustrated in FIG. 3B may be modified, rearranged, or omitted all together. Accordingly, the particular sequence of operations illustrated in FIG. 3B should not be construed as limiting the scope of one or more embodiments.

One or more embodiments include receiving an update for a particular application schema derived from a base schema (Operation 306). The update is received from a tenant associated with the particular application schema. As an example, the update may be received via the Internet using HTTP.

One or more embodiments include applying the update to the particular application schema, without modifying either the base schema or another application schema that is derived from the base schema (Operation 308). While the particular application schema is modified to incorporate the update, the base schema and other application schemas are not modified.

As an example, a particular base schema may include two data fields, “First Name” and “Last Name.” A first application schema and a second application schema may both be derived from a particular base schema. The first application schema may have added a data field named “Age.” Subsequently, an update for the first application schema may be to add another data field named “Residential Address.” The update may be applied to the first application schema, without modifying the particular base schema or the second application schema. The first application schema would then include the data fields, “First Name,” “Last Name,” “Age,” and “Residential Address.” The base schema would remain unmodified, including the data fields, “First Name” and “Last Name.” The second application schema would also remain unmodified.

In an embodiment, the update for the particular application schema is described in metadata. The metadata is stored in association with an application that is used to access a data set organized using the particular application schema. When the application receives a request from a tenant to access the data set, the particular application schema corresponding to the tenant is identified using the metadata.

5. Example Embodiments

Detailed examples are described below for purposes of clarity. Components and/or operations described below should be understood as specific examples which may not be applicable to certain embodiments. Accordingly, components and/or operations described below should not be construed as limiting the scope of any of the claims.

FIG. 4A illustrates an example of accessing isolated data sets using a same application in accordance with one or more embodiments. FIG. 4A shows tenants 502, cloud exchange 506, and application vendors 518.

Tenants 502 share computing resources provided by cloud exchange 506. Tenants 502 gain access to cloud exchange 506 through an on-boarding process 520. Through the on-boarding process 520, a tenant datastore 508 is assigned to each tenant. Users 504 corresponding to each tenant are also specified.

Each tenant datastore 508 is isolated per tenant. Each tenant datastore is associated with a tenant. As an example, each tenant datastore may be implemented in a separate pluggable database. As another example, each tenant datastore may be implemented in a separate data structure within a same database instance.

Application vendors 518 provide application definitions 512, which are maintained on the shared computing resources of cloud exchange 506, through a publishing process 522. Each application definition includes application code 514 and base schema 516. Application code 514 is configured to execute requests received from tenants 502 (such as accessing tenant datastore 508 of a particular tenant). The same application code 514 is executed for multiple tenants 502. Base schema 516 indicates data fields and other characteristics of a default datastore for the corresponding application definition.

Tenants to application subscription 510 includes a list of subscribed applications for each tenant. Subscription to a particular application gives a tenant access to the particular application. When a particular tenant subscribes to a particular application, base schema 516 of the particular application is copied as an application schema for a tenant datastore 508 of the particular tenant. The particular tenant may make customizations to the application schema for the tenant datastore 508, such as modifying names of existing data fields and/or adding new data fields.

FIG. 4B illustrates an example of different application schemas in accordance with one or more embodiments. FIG. 4B shows page 550 and page 560, both associated with a same application. Page 550 is rendered at a browser for a first tenant, HomeImprove Corp. Page 560 is rendered at a browser for a second tenant, Larry Properties Inc.

Page 550 and page 560 displays a same set of user interface elements, but the user interface elements have different configurations. Page 550 displays a heading 552, data set 554, fields 556, and button 558. Page 560 displays a heading 562, data set 564, fields 566, and button 568.

A base schema for the application used by HomeImprove Corp. and Larry Properties Inc. includes three data fields. A first data field is named “Department.” A second data field is named “Supervisor.” A third data field is named “Location.” A first application schema derived from the base schema is associated with HomeImprove Corp. A second application schema derived from the base schema is associated with Larry Properties Inc.

The number of data fields in each application schema is customized. HomeImprove Corp. specifies that an additional data field is to be added. Hence, data set 554 of HomeImprove Corp. includes four data fields. Meanwhile, Larry Properties Inc. does not specify any additional data fields. Hence, data set 564 of Larry Properties Inc. includes three data fields.

The names of data fields in each application schema are customized. HomeImprove Corp. modifies the name “Supervisor” into “Manager.” HomeImprove Corp. further specifies that the name of the newly added data field is “Type.” Meanwhile, Larry Properties Inc. modifies the name “Department” into “Office,” and modifies the name “Location” into “Building.”

Data sets 554-556 are organized according to the corresponding application schemas. Based on the application schema of HomeImprove Corp., data set 554 is organized using data fields with the names, “Department,” “Manager,” “Location,” and “Type.” Based on the application schema of Larry Properties Inc., data set 564 is organized using data fields with the names, “Office,” “Supervisor,” and “Building.”

User interface elements for adding a new record in data sets 554-556 are modified and/or customized according to the corresponding application schemas. Based on the application schema of HomeImprove Corp., four fields 556 are used for adding a new department, labeled “Department,” “Manager,” “Location,” and “Type,” respectively. Button 558, which is used to submit user input entered at fields 556, is also customized. Button 558 displays the text, “Add Department,” based on the name of the first data field being “Department.” Based on the application schema of Larry Properties Inc., three fields 566 are used for adding a new department, labeled “Office,” “Supervisor,” and “Building,” respectively. Button 568, which is used to submit user input entered at fields 566, is also customized. Button 568 displays the text, “Add Office,” based on the name of the first data field being “Office.”

Heading 552 and heading 562 are customized. Heading 552 displays “Your departments,” based on customizations of HomeImprove Corp. Heading 562 displays “Office management section,” based on customizations of Larry Properties Inc.

6. Cloud Environments

In one or more embodiments, a cloud environment provides a centralized pool of resources that are shared amongst multiple client devices. Examples of resources include a processor, a server, a data storage, a virtual machine, and a platform. Client devices may independently request computing services, such as server time and network storage, as needed. The resources are dynamically assigned to the client devices on an on-demand basis. The resources assigned to each particular client device may be scaled up or down based on the computing services requested by the particular client device. The resources assigned to each particular client device may also be scaled up or down based on the aggregated demand for computing services requested by all client devices.

In an embodiment, the resources of a cloud environment are accessible over a network, such as a private network or the Internet. One or more physical and/or virtual client devices demanding use of the resources may be local to or remote from the resources. The client devices may be any type of computing devices, such as computers or smartphones, executing any type of operating system. The client devices communicate requests to the resources using a communications protocol, such as Hypertext Transfer Protocol (HTTP). The requests are communicated to the resources through an interface, such as a client interface (such as a web browser), a program interface, or an application programming interface (API).

In an embodiment, a cloud service provider provides a cloud environment to one or more cloud users. Various service models may be implemented by the cloud environment, including but not limited to Software-as-a-Service (SaaS), Platform-as-a-Service (PaaS), and Infrastructure-as-a-Service (IaaS). In SaaS, a cloud service provider provides cloud users the capability to use the cloud service provider's applications, which are executing on the cloud resources. In PaaS, the cloud service provider provides cloud users the capability to deploy onto the cloud resources custom applications, which are created using programming languages, libraries, services, and tools supported by the cloud service provider. In IaaS, the cloud service provider provides cloud users the capability to provision processing, storage, networks, and other fundamental computing resources provided in the cloud environment. Any arbitrary applications, including an operating system, may be deployed on the cloud resources.

In an embodiment, various deployment models may be implemented by a cloud environment, including but not limited to a private cloud, a public cloud, and a hybrid cloud. In a private cloud, cloud resources are provisioned for exclusive use by a particular group of one or more entities (the term “entity” as used herein refers to a corporation, organization, person, or other entity). The cloud resources may be located on the premises of one or more entities in the particular group, and/or at one or more remote off-premise locations. In a public cloud, cloud resources are provisioned for multiple entities (also referred to herein as “tenants”). Several tenants may use a same particular resource, such as a server, at different times and/or at the same time. In a hybrid cloud, the cloud environment comprises a private cloud and a public cloud. An interface between the private cloud and the public cloud allows for data and application portability. Data stored at the private cloud and data stored at the public cloud may be exchanged through the interface. Applications implemented at the private cloud and applications implemented at the public cloud may have dependencies on each other. A call from an application at the private cloud to an application at the public cloud (and vice versa) may be executed through the interface.

In a multi-tenant environment, where multiple tenants share a same pool of resources 112, tenant isolation is implemented. Each tenant corresponds to a unique tenant identifiers (IDs). Data sets and/or applications implemented on cloud resources that are associated with a particular tenant are tagged with the tenant ID of the particular tenant. Before access to a particular data set or application is permitted, the tenant ID is verified to determine whether the corresponding tenant has authorization to access the particular data set or application.

In an embodiment, data sets corresponding to various tenants are stored as entries in a database. Each entry is tagged with the tenant ID of the corresponding tenant. A request for access to a particular data set is tagged with the tenant ID of the tenant making the request. The tenant ID associated with the request is checked against the tenant ID associated with the database entry of the data set to be accessed. If the tenant IDs are the same, then access to the database entry is permitted.

In an embodiment, data sets corresponding to various tenants are stored in different databases or data structures. Each database or data structure is tagged with the tenant ID of the corresponding tenant. A request for access to a particular data set is tagged with the tenant ID of the tenant making the request. The tenant ID associated with the request is checked against the tenant ID associated with the database or data structure storing the data set to be accessed. If the tenant IDs are the same, then access to the database or data structure is permitted.

In an embodiment, a subscription list indicates which tenants have authorization to access which applications. For each application, a list of tenant IDs of each tenant having authorization to access the application is stored. A request for access to a particular application is tagged with the tenant ID of the tenant making the request. The tenant ID associated with the request is checked against the subscription list to determine whether the tenant is authorized to access the application. If the tenant ID associated with the request is included in the list of tenant IDs of tenants having authorization to access the application, then access to the application is permitted.

In an embodiment, data sets and virtual resources (e.g., virtual machines, application instances, and threads) corresponding to different tenants are isolated to tenant-specific overlay networks maintained by the cloud environment. As an example, packets from any source device in a tenant overlay network may only be transmitted to other devices within the same tenant overlay network. Encapsulation tunnels are used to prohibit any transmissions from a source device on a tenant overlay network to devices in other tenant overlay networks. Specifically, the packets, received from the source device, are encapsulated within an outer packet. The outer packet is transmitted from a first encapsulation tunnel endpoint (in communication with the source device in the tenant overlay network) to a second encapsulation tunnel endpoint (in communication with the destination device in the tenant overlay network). The second encapsulation tunnel endpoint decapsulates the outer packet to obtain the original packet transmitted by the source device. The original packet is transmitted from the second encapsulation tunnel endpoint to the destination device in the same particular overlay network.

7. Miscellaneous; Extensions

Embodiments are directed to a system with one or more devices that include a hardware processor and that are configured to perform any of the operations described herein and/or recited in any of the claims below.

In an embodiment, a non-transitory computer readable storage medium comprises instructions which, when executed by one or more hardware processors, causes performance of any of the operations described herein and/or recited in any of the claims.

Any combination of the features and functionalities described herein may be used in accordance with one or more embodiments. In the foregoing specification, embodiments have been described with reference to numerous specific details that may vary from implementation to implementation. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. The sole and exclusive indicator of the scope of the invention, and what is intended by the applicants to be the scope of the invention, is the literal and equivalent scope of the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction.

8. Hardware Overview

According to one embodiment, the techniques described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices may be hard-wired to perform the techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or may include one or more general purpose hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. Such special-purpose computing devices may also combine custom hard-wired logic, ASICs, or FPGAs with custom programming to accomplish the techniques. The special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices or any other device that incorporates hard-wired and/or program logic to implement the techniques.

For example, FIG. 5 is a block diagram that illustrates a computer system 600 upon which an embodiment of the invention may be implemented. Computer system 600 includes a bus 602 or other communication mechanism for communicating information, and a hardware processor 604 coupled with bus 602 for processing information. Hardware processor 604 may be, for example, a general purpose microprocessor.

Computer system 600 also includes a main memory 606, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 602 for storing information and instructions to be executed by processor 604. Main memory 606 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 604. Such instructions, when stored in non-transitory storage media accessible to processor 604, render computer system 600 into a special-purpose machine that is customized to perform the operations specified in the instructions.

Computer system 600 further includes a read only memory (ROM) 608 or other static storage device coupled to bus 602 for storing static information and instructions for processor 604. A storage device 610, such as a magnetic disk or optical disk, is provided and coupled to bus 602 for storing information and instructions.

Computer system 600 may be coupled via bus 602 to a display 612, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 614, including alphanumeric and other keys, is coupled to bus 602 for communicating information and command selections to processor 604. Another type of user input device is cursor control 616, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 604 and for controlling cursor movement on display 612. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.

Computer system 600 may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system 600 to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system 600 in response to processor 604 executing one or more sequences of one or more instructions contained in main memory 606. Such instructions may be read into main memory 606 from another storage medium, such as storage device 610. Execution of the sequences of instructions contained in main memory 606 causes processor 604 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions.

The term “storage media” as used herein refers to any non-transitory media that store data and/or instructions that cause a machine to operate in a specific fashion. Such storage media may comprise non-volatile media and/or volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 610. Volatile media includes dynamic memory, such as main memory 606. Common forms of storage media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge.

Storage media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between storage media. For example, transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 602. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.

Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor 604 for execution. For example, the instructions may initially be carried on a magnetic disk or solid state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 600 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 602. Bus 602 carries the data to main memory 606, from which processor 604 retrieves and executes the instructions. The instructions received by main memory 606 may optionally be stored on storage device 610 either before or after execution by processor 604.

Computer system 600 also includes a communication interface 618 coupled to bus 602. Communication interface 618 provides a two-way data communication coupling to a network link 620 that is connected to a local network 622. For example, communication interface 618 may be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 618 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 618 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

Network link 620 typically provides data communication through one or more networks to other data devices. For example, network link 620 may provide a connection through local network 622 to a host computer 624 or to data equipment operated by an Internet Service Provider (ISP) 626. ISP 626 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 628. Local network 622 and Internet 628 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 620 and through communication interface 618, which carry the digital data to and from computer system 600, are example forms of transmission media.

Computer system 600 can send messages and receive data, including program code, through the network(s), network link 620 and communication interface 618. In the Internet example, a server 630 might transmit a requested code for an application program through Internet 628, ISP 626, local network 622 and communication interface 618.

The received code may be executed by processor 604 as it is received, and/or stored in storage device 610, or other non-volatile storage for later execution.

In the foregoing specification, embodiments of the invention have been described with reference to numerous specific details that may vary from implementation to implementation. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. The sole and exclusive indicator of the scope of the invention, and what is intended by the applicants to be the scope of the invention, is the literal and equivalent scope of the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction. 

What is claimed is:
 1. One or more non-transitory machine-readable media storing instructions which, when executed by one or more processors, cause: identifying a first datastore organized according to a first application schema derived from a base schema; identifying a second datastore organized according to a second application schema derived from the base schema; wherein the first application schema and the second application schema are different; wherein at least one data field is included in both the first application schema and the second application schema; receiving a first update for a first data field of a base schema; responsive to receiving the first update: applying the first update for the first data field of the base schema to each of the first data field of the first application schema and the first data field of the second application schema; receiving a second update for the first data field of the first application schema; and responsive to receiving the second update: applying the second update to the first data field of the first application schema, without modifying either of the second application schema or the base schema.
 2. The one or more media of claim 1, further storing instructions which, when executed by one or more processors, cause: deriving the first application schema from the base schema at least by applying a first set of modifications to the base schema to generate the first application schema; deriving the second application schema from the base schema at least by applying a second set of modifications to the base schema to generate the second application schema.
 3. The one or more media of claim 1, further storing instructions which, when executed by one or more processors, cause: adding a third data field to the base schema to generate the first application schema; adding a fourth data field to the base schema to generate the second application schema.
 4. The one or more media of claim 1, wherein: the first update comprises adding the first data field to the base schema; and applying the first update for the first data field of the base schema to each of the first data field of the first application schema and the first data field of the second application schema comprises: adding the first data field to the first application schema and adding the first data field to the second application schema.
 5. The one or more media of claim 1, wherein: the second update comprises adding a second data field to the first application schema; and the second data field is not added to the second application schema or the base schema.
 6. The one or more media of claim 1, wherein the first datastore and the second datastore are within a multi-tenant database, the first datastore is associated with a first tenant, and the second datastore is associated with a second tenant.
 7. The one or more media of claim 1, wherein a same application is used to access the first datastore and the second datastore.
 8. The one or more media of claim 1, further storing instructions which cause: receiving a third update for a second data field of the first application schema; and responsive to receiving the third update: applying the third update to the second data field of the first application schema, without modifying either of the second application schema or the base schema; wherein the second data field is not included in the base schema or the second application schema.
 9. The one or more media of claim 1, wherein an application performs a same set of operations on the first data field of the first application schema and the first data field of the second application schema.
 10. The one or more media of claim 1, wherein an application includes a first set of operations for accessing a first data set stored in the first datastore organized according to the first application schema and a second set of operations for accessing a second data set stored in the second datastore organized according to the second application schema.
 11. The one or more media of claim 1, further storing instructions which, when executed by one or more processors, cause: deriving the first application schema from the base schema at least by adding a third data field to the base schema to generate the first application schema; deriving the second application schema from the base schema at least by adding a fourth data field to the base schema to generate the second application schema; wherein the first update comprises adding the first data field to the base schema; wherein applying the first update for the first data field of the base schema to each of the first data field of the first application schema and the first data field of the second application schema comprises: adding the first data field to the first application schema and adding the first data field to the second application schema; wherein the second update comprises adding a second data field to the first application schema; wherein the second data field is not added to the second application schema or the base schema; wherein the first datastore and the second datastore are within a multi-tenant database, the first datastore is associated with a first tenant, and the second datastore is associated with a second tenant; wherein a same application is used to access the first datastore and the second datastore; wherein the application performs a same set of operations on the first data field of the first application schema and the first data field of the second application schema; wherein the application includes a first set of operations for accessing a first data set stored in the first datastore organized according to the first application schema and a second set of operations for accessing a second data set stored in the second datastore organized according to the second application schema.
 12. One or more non-transitory machine-readable media storing instructions which, when executed by one or more processors, cause: receiving, by an application, a first request for accessing a first data set stored in a first datastore organized according to a first application schema derived from a base schema; transmitting, by the application, a first response comprising at least a subset of the first data set; receiving, by the application, a second request for accessing a second data set stored in a second datastore organized according to a second application schema derived from the base schema, the second application schema being different than the first application schema; transmitting, by the application, a second response comprising at least a subset of the second data set; wherein the first application schema and the second application schema are different; wherein at least one data field is included in both the first application schema and the second application schema; wherein a first update for a first data field of the base schema is applied to the first data field of the first application schema and is applied to the first data field of the second application schema, and a second update for the first data field of the first application schema is not applied to the base schema and is not applied to the second application schema.
 13. The one or more media of claim 12, further storing instructions which, when executed by one or more processors, cause: determining a first tenant associated with the first request; determining that the first application schema is associated with the first request based on the first tenant; selecting a first set of operations for accessing the subset of the first data set based on the first application schema; executing the first set of operations to access the subset of the first data set.
 14. The one or more media of claim 12, further storing instructions which, when executed by one or more processors, cause: causing presentation of the subset of the first data set and the subset of the second data set using a same set of user interface elements.
 15. The one or more media of claim 12, wherein: the first datastore and the second datastore are associated with a same physical database, and a cache of the physical database performs caching for both the first datastore and the second datastore; the first datastore and the second datastore are associated with different caching policies.
 16. The one or more media of claim 15, wherein a first trigger for performing caching for the first datastore and a second trigger for performing caching for the second datastore are different.
 17. The one or more media of claim 15, wherein the first datastore and the second datastore are associated with different isolation levels.
 18. The one or more media of claim 15, wherein the first datastore and the second datastore are associated with different logging levels.
 19. The one or more media of claim 15, wherein a first size of a first memory within the cache of the physical database used to perform caching for the first datastore and a second size of a second memory within the cache of the physical database used to perform caching for the second datastore are different.
 20. The one or more media of claim 12, further storing instructions which, when executed by one or more processors, cause: determining a first tenant associated with the first request; determining that the first application schema is associated with the first request based on the first tenant; selecting a first set of operations for accessing the subset of the first data set based on the first application schema; executing the first set of operations to access the subset of the first data set; causing presentation of the subset of the first data set and the subset of the second data set using a same set of user interface elements; wherein the first datastore and the second datastore are associated with a same physical database, and a cache of the physical database performs caching for both the first datastore and the second datastore; wherein the first datastore and the second datastore are associated with different caching policies; wherein a first size of a first memory within the cache of the physical database used to perform caching for the first datastore and a second size of a second memory within the cache of the physical database used to perform caching for the second datastore are different; wherein a first trigger for performing caching for the first datastore and a second trigger for performing caching for the second datastore are different; wherein the first datastore and the second datastore are associated with different isolation levels; wherein the first datastore and the second datastore are associated with different logging levels.
 21. A system, comprising: at least one device including a hardware processor; and the system being configured to perform operations comprising: receiving, by an application, a first request for accessing a first data set stored in a first datastore organized according to a first application schema derived from a base schema; transmitting, by the application, a first response comprising at least a subset of the first data set; receiving, by the application, a second request for accessing a second data set stored in a second datastore organized according to a second application schema derived from the base schema, the second application schema being different than the first application schema; transmitting, by the application, a second response comprising at least a subset of the second data set; wherein the first application schema and the second application schema are different; wherein at least one data field is included in both the first application schema and the second application schema; wherein a first update for a first data field of the base schema is applied to the first data field of the first application schema and is applied to the first data field of the second application schema, and a second update for the first data field of the first application schema is not applied to the base schema and is not applied to the second application schema. 